// 数据分析页面功能
const AnalysisPage = {
    // 状态数据
    state: {
        currentTemp: 26.1,
        lightStatus: false,
        sensorData: null,
        realtimeInterval: null,
        isInitialized: false
    },

    // 初始化
    init: function() {
        if (this.state.isInitialized) {
            console.log('[AnalysisPage] 已初始化，跳过重复初始化');
            return;
        }
        
        console.log('[AnalysisPage] 初始化数据分析页面');
        
        // 绑定事件
        this.bindEvents();
        
        // 加载实时数据
        this.loadRealtimeData();
        
        // 开始定时更新（每5秒）
        this.startRealtimeUpdates();
        
        // 初始化预测图表
        this.initPredictionChart();
        
        this.state.isInitialized = true;
    },

    // 绑定事件
    bindEvents: function() {
        // 温度控制按钮
        const tempMinusBtn = document.getElementById('temp-minus');
        const tempPlusBtn = document.getElementById('temp-plus');
        
        if (tempMinusBtn) {
            tempMinusBtn.addEventListener('click', () => this.adjustTemperature(-1));
        }
        
        if (tempPlusBtn) {
            tempPlusBtn.addEventListener('click', () => this.adjustTemperature(1));
        }

        // 灯光控制按钮
        const lightToggleBtn = document.getElementById('light-toggle');
        if (lightToggleBtn) {
            lightToggleBtn.addEventListener('click', () => this.toggleLight());
        }
        
        // 预测标签页
        const tabBtns = document.querySelectorAll('.forecast-tab');
        tabBtns.forEach(btn => {
            btn.addEventListener('click', (e) => this.switchPredictionTab(e.target.dataset.type));
        });
    },

    // 调节温度
    adjustTemperature: function(delta) {
        this.state.currentTemp += delta;
        
        // 限制温度范围
        if (this.state.currentTemp < 16) this.state.currentTemp = 16;
        if (this.state.currentTemp > 30) this.state.currentTemp = 30;
        
        // 更新显示
        this.updateTemperatureDisplay();
        
        console.log(`[AnalysisPage] 温度调整为: ${this.state.currentTemp}°C`);
    },

    // 切换灯光
    toggleLight: function() {
        this.state.lightStatus = !this.state.lightStatus;
        
        const indicator = document.querySelector('.light-status-indicator');
        const btnText = document.getElementById('light-btn-text');
        
        if (indicator && btnText) {
            if (this.state.lightStatus) {
                indicator.classList.remove('off');
                indicator.classList.add('on');
                btnText.textContent = '关闭灯光';
            } else {
                indicator.classList.remove('on');
                indicator.classList.add('off');
                btnText.textContent = '开启灯光';
            }
        }
        
        console.log(`[AnalysisPage] 灯光状态: ${this.state.lightStatus ? '开启' : '关闭'}`);
    },

    // 更新温度显示
    updateTemperatureDisplay: function() {
        const tempElement = document.getElementById('current-temp');
        if (tempElement) {
            tempElement.textContent = this.state.currentTemp;
        }
    },
    
    // 切换灯光
    toggleLight: function() {
        this.state.lightStatus = !this.state.lightStatus;
        
        const lightIcon = document.querySelector('.light-icon');
        const lightBtn = document.getElementById('light-toggle');
        
        if (lightIcon && lightBtn) {
            if (this.state.lightStatus) {
                lightIcon.style.background = 'var(--warning-light)';
                lightIcon.style.color = 'var(--warning-color)';
                lightBtn.textContent = '关闭灯光';
            } else {
                lightIcon.style.background = 'var(--secondary-subtle)';
                lightIcon.style.color = 'var(--text-muted)';
                lightBtn.textContent = '开启灯光';
            }
        }
        
        console.log(`[AnalysisPage] 灯光状态: ${this.state.lightStatus ? '开启' : '关闭'}`);
    },
    
    // 切换预测标签页
    switchPredictionTab: function(type) {
        // 更新标签页状态
        const tabBtns = document.querySelectorAll('.forecast-tab');
        tabBtns.forEach(btn => {
            btn.classList.remove('active');
            if (btn.dataset.type === type) {
                btn.classList.add('active');
            }
        });
        
        // 这里可以加载不同类型的预测数据
        console.log(`[AnalysisPage] 切换到预测类型: ${type}`);
        this.loadPredictionData(type);
    },
    
    // 初始化预测图表
    initPredictionChart: function() {
        const chartContainer = document.getElementById('prediction-chart');
        if (chartContainer && typeof echarts !== 'undefined') {
            // 创建ECharts实例
            this.predictionChart = echarts.init(chartContainer);
            
            // 加载默认的温度预测数据
            this.loadPredictionData('temperature');
        } else if (chartContainer) {
            chartContainer.innerHTML = '<p>预测图表加载中...</p>';
        }
    },
    
    // 加载预测数据
    loadPredictionData: function(type = 'temperature') {
        if (!this.predictionChart) return;
        
        // 模拟24小时预测数据
        const hours = [];
        const values = [];
        const currentHour = new Date().getHours();
        
        for (let i = 0; i < 24; i++) {
            const hour = (currentHour + i) % 24;
            hours.push(`${hour}:00`);
            
            // 根据不同类型生成模拟数据
            let value;
            switch(type) {
                case 'temperature':
                    value = 22 + Math.sin(i * Math.PI / 12) * 4 + Math.random() * 2;
                    break;
                case 'light':
                    value = Math.max(0, 50 + Math.sin((i - 6) * Math.PI / 12) * 40 + Math.random() * 20);
                    break;
                case 'occupancy':
                    value = Math.max(0, Math.floor(2 + Math.sin((i - 8) * Math.PI / 10) * 2 + Math.random() * 2));
                    break;
                default:
                    value = Math.random() * 100;
            }
            values.push(Math.round(value * 10) / 10);
        }
        
        const option = {
            title: {
                text: `${type === 'temperature' ? '温度' : type === 'light' ? '光线' : '人数'}预测`,
                left: 'center',
                textStyle: {
                    fontSize: 14,
                    color: '#333'
                }
            },
            tooltip: {
                trigger: 'axis',
                formatter: function(params) {
                    const unit = type === 'temperature' ? '°C' : type === 'light' ? 'lux' : '人';
                    return `${params[0].axisValue}<br/>${params[0].seriesName}: ${params[0].value}${unit}`;
                }
            },
            xAxis: {
                type: 'category',
                data: hours,
                axisLabel: {
                    interval: 2
                }
            },
            yAxis: {
                type: 'value',
                name: type === 'temperature' ? '°C' : type === 'light' ? 'lux' : '人数'
            },
            series: [{
                name: type === 'temperature' ? '温度' : type === 'light' ? '光线强度' : '人数',
                type: 'line',
                data: values,
                smooth: true,
                lineStyle: {
                    width: 3,
                    color: type === 'temperature' ? '#ff6b6b' : type === 'light' ? '#ffd93d' : '#6bcf7e'
                },
                itemStyle: {
                    color: type === 'temperature' ? '#ff6b6b' : type === 'light' ? '#ffd93d' : '#6bcf7e'
                },
                areaStyle: {
                    opacity: 0.3,
                    color: type === 'temperature' ? '#ff6b6b' : type === 'light' ? '#ffd93d' : '#6bcf7e'
                }
            }]
        };
        
        this.predictionChart.setOption(option);
    },

    // 加载实时传感器数据
    loadRealtimeData: function() {
        fetch('/api/sensor/realtime')
            .then(response => response.json())
            .then(data => {
                if (data.status === 'success' || data.status === 'simulated') {
                    console.log('[AnalysisPage] 传感器数据加载成功:', data);
                    this.state.sensorData = data;
                    
                    // 更新温度显示（使用传感器数据）
                    if (data.current_temperature) {
                        this.state.currentTemp = data.current_temperature;
                        this.updateTemperatureDisplay();
                    }
                    
                    // 更新环境数据
                    this.updateEnvironmentData(data);
                } else {
                    console.error('[AnalysisPage] 传感器数据加载失败:', data.message);
                }
            })
            .catch(error => {
                console.error('[AnalysisPage] 获取传感器数据时出错:', error);
            });
    },

    // 更新环境数据
    updateEnvironmentData: function(sensorData) {
        if (!sensorData || !sensorData.sensors) return;

        // 更新紫外线数据（模拟）
        this.updateProgressRing('.circular-progress.uv', 20, '2', 'UV');
        
        // 更新湿度数据（模拟）
        this.updateProgressRing('.circular-progress.humidity', 81, '81%');
        
        // 更新体感温度数据（模拟）
        this.updateProgressRing('.circular-progress.feels-like', 70, '29°');
        
        // 更新日落时间
        const timeValue = document.querySelector('.time-value');
        if (timeValue) {
            timeValue.textContent = '19:26';
        }
    },

    // 更新进度圆环
    updateProgressRing: function(selector, progress, value, unit = '') {
        const ring = document.querySelector(selector);
        if (ring) {
            // 设置CSS变量来控制进度
            ring.style.setProperty('--progress', progress);
            
            // 更新显示值
            const valueElement = ring.querySelector('.progress-value');
            if (valueElement) {
                valueElement.textContent = value;
            }
            
            // 更新单位（如果有）
            if (unit) {
                const unitElement = ring.querySelector('.progress-unit');
                if (unitElement) {
                    unitElement.textContent = unit;
                }
            }
        }
    },

    // 初始化进度圆环
    initProgressRings: function() {
        // 设置初始进度值
        this.updateProgressRing('.circular-progress.uv', 20, '2', 'UV');
        this.updateProgressRing('.circular-progress.humidity', 81, '81%');
        this.updateProgressRing('.circular-progress.feels-like', 70, '29°');
    },

    // 开始实时数据更新
    startRealtimeUpdates: function() {
        // 清除现有定时器
        if (this.state.realtimeInterval) {
            clearInterval(this.state.realtimeInterval);
        }
        
        // 设置10秒定时更新（减少服务器负载）
        this.state.realtimeInterval = setInterval(() => {
            this.loadRealtimeData();
        }, 10000);
        
        console.log('[AnalysisPage] 实时数据更新已启动（每10秒）');
    },

    // 停止实时数据更新
    stopRealtimeUpdates: function() {
        if (this.state.realtimeInterval) {
            clearInterval(this.state.realtimeInterval);
            this.state.realtimeInterval = null;
            console.log('[AnalysisPage] 实时数据更新已停止');
        }
    },

    // 调整图表大小
    resizeCharts: function() {
        if (this.predictionChart) {
            this.predictionChart.resize();
        }
    },

    // 页面销毁时清理
    destroy: function() {
        this.stopRealtimeUpdates();
        if (this.predictionChart) {
            this.predictionChart.dispose();
        }
        console.log('[AnalysisPage] 页面已清理');
    }
};

// 全局函数（供HTML调用）
window.adjustTemperature = function(delta) {
    AnalysisPage.adjustTemperature(delta);
};

window.toggleLight = function() {
    AnalysisPage.toggleLight();
};

// 导出模块
if (typeof module !== 'undefined' && module.exports) {
    module.exports = AnalysisPage;
}

// 将AnalysisPage绑定到全局
window.AnalysisPage = AnalysisPage;